Trait anoma_apps::std::prelude::rust_2018::From1.0.0[][src]

pub trait From<T> {
    fn from(T) -> Self;
}
Expand description

Used to do value-to-value conversions while consuming the input value. It is the reciprocal of Into.

One should always prefer implementing From over Into because implementing From automatically provides one with an implementation of Into thanks to the blanket implementation in the standard library.

Only implement Into when targeting a version prior to Rust 1.41 and converting to a type outside the current crate. From was not able to do these types of conversions in earlier versions because of Rust’s orphaning rules. See Into for more details.

Prefer using Into over using From when specifying trait bounds on a generic function. This way, types that directly implement Into can be used as arguments as well.

The From is also very useful when performing error handling. When constructing a function that is capable of failing, the return type will generally be of the form Result<T, E>. The From trait simplifies error handling by allowing a function to return a single error type that encapsulate multiple error types. See the “Examples” section and the book for more details.

Note: This trait must not fail. If the conversion can fail, use TryFrom.

Generic Implementations

  • From<T> for U implies Into<U> for T
  • From is reflexive, which means that From<T> for T is implemented

Examples

String implements From<&str>:

An explicit conversion from a &str to a String is done as follows:

let string = "hello".to_string();
let other_string = String::from("hello");

assert_eq!(string, other_string);

While performing error handling it is often useful to implement From for your own error type. By converting underlying error types to our own custom error type that encapsulates the underlying error type, we can return a single error type without losing information on the underlying cause. The ‘?’ operator automatically converts the underlying error type to our custom error type by calling Into<CliError>::into which is automatically provided when implementing From. The compiler then infers which implementation of Into should be used.

use std::fs;
use std::io;
use std::num;

enum CliError {
    IoError(io::Error),
    ParseError(num::ParseIntError),
}

impl From<io::Error> for CliError {
    fn from(error: io::Error) -> Self {
        CliError::IoError(error)
    }
}

impl From<num::ParseIntError> for CliError {
    fn from(error: num::ParseIntError) -> Self {
        CliError::ParseError(error)
    }
}

fn open_and_parse_file(file_name: &str) -> Result<i32, CliError> {
    let mut contents = fs::read_to_string(&file_name)?;
    let num: i32 = contents.trim().parse()?;
    Ok(num)
}

Required methods

Performs the conversion.

Implementations on Foreign Types

Converts an Ipv4Addr into a host byte order u32.

Examples

use std::net::Ipv4Addr;

let addr = Ipv4Addr::new(0xca, 0xfe, 0xba, 0xbe);
assert_eq!(0xcafebabe, u32::from(addr));

Convert an Ipv6Addr into a host byte order u128.

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::new(
    0x1020, 0x3040, 0x5060, 0x7080,
    0x90A0, 0xB0C0, 0xD0E0, 0xF00D,
);
assert_eq!(0x102030405060708090A0B0C0D0E0F00D_u128, u128::from(addr));

Converts f32 to f64 losslessly.

Converts u8 to f32 losslessly.

Converts u32 to u64 losslessly.

Converts u8 to u128 losslessly.

Converts a NonZeroU16 into an u16

Converts a char into a u64.

Examples

use std::mem;

let c = '👤';
let u = u64::from(c);
assert!(8 == mem::size_of_val(&u))

Converts a NonZeroI32 into an i32

Maps a byte in 0x00..=0xFF to a char whose code point has the same value, in U+0000..=U+00FF.

Unicode is designed such that this effectively decodes bytes with the character encoding that IANA calls ISO-8859-1. This encoding is compatible with ASCII.

Note that this is different from ISO/IEC 8859-1 a.k.a. ISO 8859-1 (with one less hyphen), which leaves some “blanks”, byte values that are not assigned to any character. ISO-8859-1 (the IANA one) assigns them to the C0 and C1 control codes.

Note that this is also different from Windows-1252 a.k.a. code page 1252, which is a superset ISO/IEC 8859-1 that assigns some (not all!) blanks to punctuation and various Latin characters.

To confuse things further, on the Web ascii, iso-8859-1, and windows-1252 are all aliases for a superset of Windows-1252 that fills the remaining blanks with corresponding C0 and C1 control codes.

Converts a u8 into a char.

Examples

use std::mem;

let u = 32 as u8;
let c = char::from(u);
assert!(4 == mem::size_of_val(&c))

Converts a bool to a u16. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(u16::from(true), 1);
assert_eq!(u16::from(false), 0);

Converts a bool to a i128. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(i128::from(true), 1);
assert_eq!(i128::from(false), 0);

Converts i8 to f32 losslessly.

Converts u8 to u16 losslessly.

Converts u32 to i64 losslessly.

Converts a NonZeroI16 into an i16

Converts i8 to i64 losslessly.

Converts i32 to i128 losslessly.

Converts i8 to i128 losslessly.

Converts u16 to i32 losslessly.

Converts a NonZeroI128 into an i128

Converts i16 to isize losslessly.

Converts u8 to isize losslessly.

Converts u8 to usize losslessly.

Converts i16 to i32 losslessly.

Converts a bool to a u32. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(u32::from(true), 1);
assert_eq!(u32::from(false), 0);

Converts u32 to f64 losslessly.

Converts a char into a u32.

Examples

use std::mem;

let c = 'c';
let u = u32::from(c);
assert!(4 == mem::size_of_val(&u))

Converts a bool to a i32. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(i32::from(true), 1);
assert_eq!(i32::from(false), 0);

Converts i32 to i64 losslessly.

Converts u32 to u128 losslessly.

Converts i16 to i128 losslessly.

Converts u8 to u64 losslessly.

Converts i16 to f32 losslessly.

Converts i8 to f64 losslessly.

Converts u8 to i128 losslessly.

Converts a bool to a isize. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(isize::from(true), 1);
assert_eq!(isize::from(false), 0);

Converts i8 to isize losslessly.

Converts a NonZeroI64 into an i64

Converts a bool to a i8. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(i8::from(true), 1);
assert_eq!(i8::from(false), 0);

Converts a NonZeroI8 into an i8

Converts u16 to usize losslessly.

Converts u16 to f64 losslessly.

Converts a NonZeroIsize into an isize

Converts a bool to a u128. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(u128::from(true), 1);
assert_eq!(u128::from(false), 0);

Converts a NonZeroU8 into an u8

Converts u8 to u32 losslessly.

Converts a NonZeroUsize into an usize

Converts u16 to i128 losslessly.

Converts u16 to u32 losslessly.

Converts u16 to u128 losslessly.

Converts a char into a u128.

Examples

use std::mem;

let c = '⚙';
let u = u128::from(c);
assert!(16 == mem::size_of_val(&u))

Converts i8 to i16 losslessly.

Converts a NonZeroU128 into an u128

Converts a bool to a usize. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(usize::from(true), 1);
assert_eq!(usize::from(false), 0);

Converts a bool to a u64. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(u64::from(true), 1);
assert_eq!(u64::from(false), 0);

Converts a NonZeroU64 into an u64

Converts i16 to i64 losslessly.

Converts u8 to i16 losslessly.

Converts u64 to u128 losslessly.

Converts u8 to i32 losslessly.

Converts u8 to i64 losslessly.

Converts a bool to a u8. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(u8::from(true), 1);
assert_eq!(u8::from(false), 0);

Converts a NonZeroU32 into an u32

Converts u8 to f64 losslessly.

Converts i16 to f64 losslessly.

Converts u32 to i128 losslessly.

Converts i8 to i32 losslessly.

Converts u16 to i64 losslessly.

Converts u64 to i128 losslessly.

Converts a bool to a i64. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(i64::from(true), 1);
assert_eq!(i64::from(false), 0);

Converts a bool to a i16. The resulting value is 0 for false and 1 for true values.

Examples

assert_eq!(i16::from(true), 1);
assert_eq!(i16::from(false), 0);

Converts u16 to f32 losslessly.

Converts i32 to f64 losslessly.

Converts i64 to i128 losslessly.

Converts u16 to u64 losslessly.

Warning: f64 loses precision and it should not be used when exact values are required.

Warning: f64 loses precision and it should not be used when exact values are required.

Convert a DateTime<Local> instance into a DateTime<FixedOffset> instance.

Convert this DateTime<Local> instance into a DateTime<FixedOffset> instance.

Conversion is performed via DateTime::with_timezone. Note that the converted value returned by this will be created with a fixed timezone offset of 0.

Convert a DateTime<Utc> instance into a DateTime<FixedOffset> instance.

Convert this DateTime<Utc> instance into a DateTime<FixedOffset> instance.

Conversion is done via DateTime::with_timezone. Note that the converted value returned by this will be created with a fixed timezone offset of 0.

Convert a DateTime<FixedOffset> instance into a DateTime<Local> instance.

Convert this DateTime<FixedOffset> instance into a DateTime<Local> instance.

Conversion is performed via DateTime::with_timezone. Returns the equivalent value in local time.

Convert a DateTime<Local> instance into a DateTime<Utc> instance.

Convert this DateTime<Local> instance into a DateTime<Utc> instance.

Conversion is performed via DateTime::with_timezone, accounting for the difference in timezones.

Convert a DateTime<Utc> instance into a DateTime<Local> instance.

Convert this DateTime<Utc> instance into a DateTime<Local> instance.

Conversion is performed via DateTime::with_timezone, accounting for the difference in timezones.

Convert a DateTime<FixedOffset> instance into a DateTime<Utc> instance.

Convert this DateTime<FixedOffset> instance into a DateTime<Utc> instance.

Conversion is performed via DateTime::with_timezone, accounting for the timezone difference.

Convert a Uri from parts

Examples

Relative URI

let mut parts = Parts::default();
parts.path_and_query = Some("/foo".parse().unwrap());

let uri = Uri::from_parts(parts).unwrap();

assert_eq!(uri.path(), "/foo");

assert!(uri.scheme().is_none());
assert!(uri.authority().is_none());

Absolute URI

let mut parts = Parts::default();
parts.scheme = Some("http".parse().unwrap());
parts.authority = Some("foo.com".parse().unwrap());
parts.path_and_query = Some("/foo".parse().unwrap());

let uri = Uri::from_parts(parts).unwrap();

assert_eq!(uri.scheme().unwrap().as_str(), "http");
assert_eq!(uri.authority().unwrap(), "foo.com");
assert_eq!(uri.path(), "/foo");

Notes

The underlying pipe is not set to non-blocking.

Notes

The underlying pipe is not set to non-blocking.

Notes

The underlying pipe is not set to non-blocking.

Optional

This function requires enabling the stream feature in your Cargo.toml.

On Windows, a corresponding From<&impl AsRawSocket> implementation exists.

The caller must ensure S is actually a socket.

Converts a std::time::Duration to a Duration.

Info -> SimpleValidator

Convert the Choice wrapper into a bool, depending on whether the underlying u8 was a 0 or a 1.

Note

This function exists to avoid having higher-level cryptographic protocol implementations duplicating this pattern.

The intended use case for this conversion is at the end of a higher-level primitive implementation: for example, in checking a keyed MAC, where the verification should happen in constant-time (and thus use a Choice) but it is safe to return a bool at the end of the verification.

Converts slice to a generic array reference with inferred length;

Length of the slice must be equal to the length of the array.

Converts mutable slice to a mutable generic array reference

Length of the slice must be equal to the length of the array.

Create level by number

Calls AsRef::as_mut then uses the full slice as the initial length.

Example

let mut arr = [0, 0];
let mut sv = SliceVec::from(&mut arr);

The output has a length equal to the full array.

If you want to select a length, use from_array_len

Uses the full slice as the initial length.

Example

let mut arr = [0_i32; 2];
let mut sv = SliceVec::from(&mut arr[..]);

Derive this public key from its corresponding SecretKey.

Derive this public key from its corresponding ExpandedSecretKey.

Construct an ExpandedSecretKey from a SecretKey.

Examples

use rand::rngs::OsRng;
use ed25519_dalek::{SecretKey, ExpandedSecretKey};

let mut csprng = OsRng{};
let secret_key: SecretKey = SecretKey::generate(&mut csprng);
let expanded_secret_key: ExpandedSecretKey = ExpandedSecretKey::from(&secret_key);

Construct a scalar from the given u64.

Inputs

An u64 to convert to a Scalar.

Returns

A Scalar corresponding to the input u64.

Example

use curve25519_dalek::scalar::Scalar;

let fourtytwo = Scalar::from(42u64);
let six = Scalar::from(6u64);
let seven = Scalar::from(7u64);

assert!(fourtytwo == six * seven);

Convert Number to Value

Examples

use serde_json::{Number, Value};

let n = Number::from(7);
let x: Value = n.into();

Convert string slice to Value

Examples

use serde_json::Value;

let s: &str = "lorem";
let x: Value = s.into();

Convert String to Value

Examples

use serde_json::Value;

let s: String = "lorem".to_string();
let x: Value = s.into();

Convert 64-bit floating point number to Value

Examples

use serde_json::Value;

let f: f64 = 13.37;
let x: Value = f.into();

Convert () to Value

Examples

use serde_json::Value;

let u = ();
let x: Value = u.into();

Convert a Vec to Value

Examples

use serde_json::Value;

let v = vec!["lorem", "ipsum", "dolor"];
let x: Value = v.into();

Convert boolean to Value

Examples

use serde_json::Value;

let b = false;
let x: Value = b.into();

Convert a slice to Value

Examples

use serde_json::Value;

let v: &[&str] = &["lorem", "ipsum", "dolor"];
let x: Value = v.into();

Convert copy-on-write string to Value

Examples

use serde_json::Value;
use std::borrow::Cow;

let s: Cow<str> = Cow::Borrowed("lorem");
let x: Value = s.into();
use serde_json::Value;
use std::borrow::Cow;

let s: Cow<str> = Cow::Owned("lorem".to_string());
let x: Value = s.into();

Convert map (with string keys) to Value

Examples

use serde_json::{Map, Value};

let mut m = Map::new();
m.insert("Lorem".to_string(), "ipsum".into());
let x: Value = m.into();

Convert 32-bit floating point number to Value

Examples

use serde_json::Value;

let f: f32 = 13.37;
let x: Value = f.into();

Convert from Result to Either with Ok => Right and Err => Left.

Given ..=high, then a size range [0, high] is the result.

Given ..high, then a size range [0, high) is the result.

Creates a Probability from a f64.

Panics

Panics if the probability is outside interval [0.0, 1.0].

Given (low: usize, high: usize), then a size range of [low..high) is the result.

Given low ..= high, then a size range [low, high] is the result.

Given exact, then a size range of [exact, exact] is the result.

Given low .. high, then a size range [low, high) is the result.

Create an ArrayVec from an array.

use arrayvec::ArrayVec;

let mut array = ArrayVec::from([1, 2, 3]);
assert_eq!(array.len(), 3);
assert_eq!(array.capacity(), 3);

Convert an option into its packed equivalent.

Convert t into a packed Some(x).

Convenience converter for making error-reporting less verbose.

Converts a tuple of (location, context, message) to a VerifierError.

use cranelift_codegen::verifier::VerifierErrors;
use cranelift_codegen::ir::Inst;
let mut errors = VerifierErrors::new();
errors.report((Inst::from_u32(42), "v3 = iadd v1, v2", "iadd cannot be used with values of this type"));
// note the double parenthenses to use this syntax

Convenience converter for making error-reporting less verbose.

Same as above but without context.

Convert t into a packed Some(x).

Convert an option into its packed equivalent.

Returns a new atomic pointer pointing to raw.

Examples

use std::ptr;
use crossbeam_epoch::Atomic;

let a = Atomic::<i32>::from(ptr::null::<i32>());

Returns a new atomic pointer pointing to ptr.

Examples

use crossbeam_epoch::{Atomic, Shared};

let a = Atomic::<i32>::from(Shared::<i32>::null());

Returns a new owned pointer pointing to b.

Panics

Panics if the pointer (the Box) is not properly aligned.

Examples

use crossbeam_epoch::Owned;

let o = unsafe { Owned::from_raw(Box::into_raw(Box::new(1234))) };

Returns a new pointer pointing to raw.

Panics

Panics if raw is not properly aligned.

Examples

use crossbeam_epoch::Shared;

let p = Shared::from(Box::into_raw(Box::new(1234)) as *const _);
assert!(!p.is_null());

Returns a new atomic pointer pointing to owned.

Examples

use crossbeam_epoch::{Atomic, Owned};

let a = Atomic::<i32>::from(Owned::new(1234));

Demote a Secp256k1 keypair into a secret key.

Promote a Secp256k1 secret key into a keypair.

Demote an Ed25519 keypair to a secret key.

Promote an Ed25519 secret key into a keypair.

Converts slice to a generic array reference with inferred length;

Length of the slice must be equal to the length of the array.

Converts mutable slice to a mutable generic array reference

Length of the slice must be equal to the length of the array.

Convert the Choice wrapper into a bool, depending on whether the underlying u8 was a 0 or a 1.

Note

This function exists to avoid having higher-level cryptographic protocol implementations duplicating this pattern.

The intended use case for this conversion is at the end of a higher-level primitive implementation: for example, in checking a keyed MAC, where the verification should happen in constant-time (and thus use a Choice) but it is safe to return a bool at the end of the verification.

used for ordering purposes. The highest priority is placed on open connections

This returns a Resource Record that is formatted for Edns(0). Note: the rcode_high value is only part of the rcode, the rest is part of the base

Convert from OpCode to u8

use std::convert::From;
use trust_dns_proto::op::op_code::OpCode;

let var: u8 = From::from(OpCode::Query);
assert_eq!(0, var);

let var: u8 = OpCode::Query.into();
assert_eq!(0, var);

Convert from DNSClass to u16

use trust_dns_proto::rr::dns_class::DNSClass;

let var: u16 = DNSClass::IN.into();
assert_eq!(1, var);

Convert from ResponseCode to u16

use std::convert::From;
use trust_dns_proto::op::response_code::ResponseCode;

let var: ResponseCode = From::from(0);
assert_eq!(ResponseCode::NoError, var);

let var: ResponseCode = 0.into();
assert_eq!(ResponseCode::NoError, var);

Convert from u16 to ResponseCode

use std::convert::From;
use trust_dns_proto::op::response_code::ResponseCode;

let var: u16 = From::from(ResponseCode::NoError);
assert_eq!(0, var);

let var: u16 = ResponseCode::NoError.into();
assert_eq!(0, var);

Convert from DNSClass to &str

use trust_dns_proto::rr::dns_class::DNSClass;

let var: &'static str = DNSClass::IN.into();
assert_eq!("IN", var);

only the supported extensions are listed right now.

Convert from RecordType to u16

use std::convert::From;
use trust_dns_proto::rr::record_type::RecordType;

let var: u16 = RecordType::A.into();
assert_eq!(1, var);

Convert from RecordType to &str

use std::convert::From;
use trust_dns_proto::rr::record_type::RecordType;

let var: &'static str = From::from(RecordType::A);
assert_eq!("A", var);

let var: &'static str = RecordType::A.into();
assert_eq!("A", var);

Convert from u16 to RecordType

use trust_dns_proto::rr::record_type::RecordType;

let var = RecordType::from(1);
assert_eq!(RecordType::A, var);

Converts a std::os::unix::net::UnixStream into its asynchronous equivalent.

Converts a std::os::unix::net::UnixDatagram into its asynchronous equivalent.

Converts a std::net::TcpStream into its asynchronous equivalent.

Converts a std::net::UdpSocket into its asynchronous equivalent.

Converts a std::os::unix::net::UnixListener into its asynchronous equivalent.

Converts a std::net::TcpListener into its asynchronous equivalent.

Converts a CuckooFilter into a simplified version which can be serialized and stored for later use.

Converts a simplified representation of a filter used for export to a fully functioning version.

Contents

  • values - A serialized version of the CuckooFilter’s memory, where the fingerprints in each bucket are chained one after another, then in turn all buckets are chained together.
  • length - The number of valid fingerprints inside the CuckooFilter. This value is used as a time saving method, otherwise all fingerprints would need to be checked for equivalence against the null pattern.

Promote a X25519 secret key into a keypair.

Promote a X25519 secret key into a keypair.

Load a secret key from a byte array.

Given an x25519 StaticSecret key, compute its corresponding PublicKey.

Given an x25519 EphemeralSecret key, compute its corresponding PublicKey.

Given a byte array, construct a x25519 PublicKey.

Implemented for drop-in replacement support for colored

You can turn a Colour into a Style with the foreground colour set with the From trait.

use ansi_term::{Style, Colour};
let green_foreground = Style::default().fg(Colour::Green);
assert_eq!(green_foreground, Colour::Green.normal());
assert_eq!(green_foreground, Colour::Green.into());
assert_eq!(green_foreground, Style::from(Colour::Green));

Make an object from a byte array.

Make an object from a byte array.

Make an object from a byte array.

Make an object from a byte array.

Make an object from a byte array.

Make an object from a byte array.

Make an object from a byte array.

Make an object from a byte array.

Make an object from a byte array.

Make an object from a byte array.

Make an object from a byte array.

Make an object from a byte array.

Implementors

Intended for use for errors not exposed to the user, where allocating onto the heap (for normal construction via Error::new) is too costly.

Converts an ErrorKind into an Error.

This conversion allocates a new error with a simple representation of error kind.

Examples

use std::io::{Error, ErrorKind};

let not_found = ErrorKind::NotFound;
let error = Error::from(not_found);
assert_eq!("entity not found", format!("{}", error));

Creates an IpAddr::V4 from a four element byte array.

Examples

use std::net::{IpAddr, Ipv4Addr};

let addr = IpAddr::from([13u8, 12u8, 11u8, 10u8]);
assert_eq!(IpAddr::V4(Ipv4Addr::new(13, 12, 11, 10)), addr);

Creates an Ipv4Addr from a four element byte array.

Examples

use std::net::Ipv4Addr;

let addr = Ipv4Addr::from([13u8, 12u8, 11u8, 10u8]);
assert_eq!(Ipv4Addr::new(13, 12, 11, 10), addr);

Creates an IpAddr::V6 from a sixteen element byte array.

Examples

use std::net::{IpAddr, Ipv6Addr};

let addr = IpAddr::from([
    25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8,
    17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8,
]);
assert_eq!(
    IpAddr::V6(Ipv6Addr::new(
        0x1918, 0x1716,
        0x1514, 0x1312,
        0x1110, 0x0f0e,
        0x0d0c, 0x0b0a
    )),
    addr
);

Creates an Ipv6Addr from a sixteen element byte array.

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::from([
    25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8,
    17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8,
]);
assert_eq!(
    Ipv6Addr::new(
        0x1918, 0x1716,
        0x1514, 0x1312,
        0x1110, 0x0f0e,
        0x0d0c, 0x0b0a
    ),
    addr
);

Creates an IpAddr::V6 from an eight element 16-bit array.

Examples

use std::net::{IpAddr, Ipv6Addr};

let addr = IpAddr::from([
    525u16, 524u16, 523u16, 522u16,
    521u16, 520u16, 519u16, 518u16,
]);
assert_eq!(
    IpAddr::V6(Ipv6Addr::new(
        0x20d, 0x20c,
        0x20b, 0x20a,
        0x209, 0x208,
        0x207, 0x206
    )),
    addr
);

Creates an Ipv6Addr from an eight element 16-bit array.

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::from([
    525u16, 524u16, 523u16, 522u16,
    521u16, 520u16, 519u16, 518u16,
]);
assert_eq!(
    Ipv6Addr::new(
        0x20d, 0x20c,
        0x20b, 0x20a,
        0x209, 0x208,
        0x207, 0x206
    ),
    addr
);

Converts a bool into an AtomicBool.

Examples

use std::sync::atomic::AtomicBool;
let atomic_bool = AtomicBool::from(true);
assert_eq!(format!("{:?}", atomic_bool), "true")

Allocates an owned String from a single character.

Example

let c: char = 'a';
let s: String = String::from(c);
assert_eq!("a", &s[..]);

Converts an i8 into an AtomicI8.

Converts an i16 into an AtomicI16.

Converts an i32 into an AtomicI32.

Converts an i64 into an AtomicI64.

Converts an isize into an AtomicIsize.

Converts an u8 into an AtomicU8.

Converts an u16 into an AtomicU16.

Converts a host byte order u32 into an Ipv4Addr.

Examples

use std::net::Ipv4Addr;

let addr = Ipv4Addr::from(0xcafebabe);
assert_eq!(Ipv4Addr::new(0xca, 0xfe, 0xba, 0xbe), addr);

Converts an u32 into an AtomicU32.

Converts an u64 into an AtomicU64.

Convert a host byte order u128 into an Ipv6Addr.

Examples

use std::net::Ipv6Addr;

let addr = Ipv6Addr::from(0x102030405060708090A0B0C0D0E0F00D_u128);
assert_eq!(
    Ipv6Addr::new(
        0x1020, 0x3040, 0x5060, 0x7080,
        0x90A0, 0xB0C0, 0xD0E0, 0xF00D,
    ),
    addr);

Converts an usize into an AtomicUsize.

Converts the given boxed str slice to a String. It is notable that the str slice is owned.

Examples

Basic usage:

let s1: String = String::from("hello world");
let s2: Box<str> = s1.into_boxed_str();
let s3: String = String::from(s2);

assert_eq!("hello world", s3)

Converts a Box<CStr> into a CString without copying or allocating.

Converts a Box<OsStr> into an OsString without copying or allocating.

Converts a Box<Path> into a PathBuf

This conversion does not allocate or copy memory.

Converts a CString into a Box<CStr> without copying or allocating.

Converts a CString into a Rc<CStr> without copying or allocating.

Converts a CString into a Arc<CStr> without copying or allocating.

Converts a CString into a Vec<u8>.

The conversion consumes the CString, and removes the terminating NUL byte.

Converts a NulError into a io::Error.

Converts a OsString into a Box<OsStr> without copying or allocating.

Converts an OsString into a PathBuf

This conversion does not allocate or copy memory.

Converts a OsString into a Rc<OsStr> without copying or allocating.

Converts a OsString into a Arc<OsStr> without copying or allocating.

Converts a File into a Stdio

Examples

File will be converted to Stdio using Stdio::from under the hood.

use std::fs::File;
use std::process::Command;

// With the `foo.txt` file containing `Hello, world!"
let file = File::open("foo.txt").unwrap();

let reverse = Command::new("rev")
    .stdin(file)  // Implicit File conversion into a Stdio
    .output()
    .expect("failed reverse command");

assert_eq!(reverse.stdout, b"!dlrow ,olleH");

Copies this address to a new IpAddr::V4.

Examples

use std::net::{IpAddr, Ipv4Addr};

let addr = Ipv4Addr::new(127, 0, 0, 1);

assert_eq!(
    IpAddr::V4(addr),
    IpAddr::from(addr)
)

Copies this address to a new IpAddr::V6.

Examples

use std::net::{IpAddr, Ipv6Addr};

let addr = Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff);

assert_eq!(
    IpAddr::V6(addr),
    IpAddr::from(addr)
);

Converts a SocketAddrV4 into a SocketAddr::V4.

Converts a SocketAddrV6 into a SocketAddr::V6.

Converts NonZeroI8 to NonZeroI16 losslessly.

Converts NonZeroI8 to NonZeroI32 losslessly.

Converts NonZeroI8 to NonZeroI64 losslessly.

Converts NonZeroI8 to NonZeroI128 losslessly.

Converts NonZeroI8 to NonZeroIsize losslessly.

Converts NonZeroI16 to NonZeroI32 losslessly.

Converts NonZeroI16 to NonZeroI64 losslessly.

Converts NonZeroI16 to NonZeroI128 losslessly.

Converts NonZeroI16 to NonZeroIsize losslessly.

Converts NonZeroI32 to NonZeroI64 losslessly.

Converts NonZeroI32 to NonZeroI128 losslessly.

Converts NonZeroI64 to NonZeroI128 losslessly.

Converts NonZeroU8 to NonZeroI16 losslessly.

Converts NonZeroU8 to NonZeroI32 losslessly.

Converts NonZeroU8 to NonZeroI64 losslessly.

Converts NonZeroU8 to NonZeroI128 losslessly.

Converts NonZeroU8 to NonZeroIsize losslessly.

Converts NonZeroU8 to NonZeroU16 losslessly.

Converts NonZeroU8 to NonZeroU32 losslessly.

Converts NonZeroU8 to NonZeroU64 losslessly.

Converts NonZeroU8 to NonZeroU128 losslessly.

Converts NonZeroU8 to NonZeroUsize losslessly.

Converts NonZeroU16 to NonZeroI32 losslessly.

Converts NonZeroU16 to NonZeroI64 losslessly.

Converts NonZeroU16 to NonZeroI128 losslessly.

Converts NonZeroU16 to NonZeroU32 losslessly.

Converts NonZeroU16 to NonZeroU64 losslessly.

Converts NonZeroU16 to NonZeroU128 losslessly.

Converts NonZeroU16 to NonZeroUsize losslessly.

Converts NonZeroU32 to NonZeroI64 losslessly.

Converts NonZeroU32 to NonZeroI128 losslessly.

Converts NonZeroU32 to NonZeroU64 losslessly.

Converts NonZeroU32 to NonZeroU128 losslessly.

Converts NonZeroU64 to NonZeroI128 losslessly.

Converts NonZeroU64 to NonZeroU128 losslessly.

Converts a PathBuf into a Box<Path>

This conversion currently should not allocate memory, but this behavior is not guaranteed on all platforms or in all future versions.

Converts a PathBuf into an OsString

This conversion does not allocate or copy memory.

Converts a PathBuf into an Rc by moving the PathBuf data into a new Rc buffer.

Converts a PathBuf into an Arc by moving the PathBuf data into a new Arc buffer.

Converts a ChildStderr into a Stdio

Examples

use std::process::{Command, Stdio};

let reverse = Command::new("rev")
    .arg("non_existing_file.txt")
    .stderr(Stdio::piped())
    .spawn()
    .expect("failed reverse command");

let cat = Command::new("cat")
    .arg("-")
    .stdin(reverse.stderr.unwrap()) // Converted into a Stdio here
    .output()
    .expect("failed echo command");

assert_eq!(
    String::from_utf8_lossy(&cat.stdout),
    "rev: cannot open non_existing_file.txt: No such file or directory\n"
);

Converts a ChildStdin into a Stdio

Examples

ChildStdin will be converted to Stdio using Stdio::from under the hood.

use std::process::{Command, Stdio};

let reverse = Command::new("rev")
    .stdin(Stdio::piped())
    .spawn()
    .expect("failed reverse command");

let _echo = Command::new("echo")
    .arg("Hello, world!")
    .stdout(reverse.stdin.unwrap()) // Converted into a Stdio here
    .output()
    .expect("failed echo command");

// "!dlrow ,olleH" echoed to console

Converts a ChildStdout into a Stdio

Examples

ChildStdout will be converted to Stdio using Stdio::from under the hood.

use std::process::{Command, Stdio};

let hello = Command::new("echo")
    .arg("Hello, world!")
    .stdout(Stdio::piped())
    .spawn()
    .expect("failed echo command");

let reverse = Command::new("rev")
    .stdin(hello.stdout.unwrap())  // Converted into a Stdio here
    .output()
    .expect("failed reverse command");

assert_eq!(reverse.stdout, b"!dlrow ,olleH\n");

Converts the given String to a boxed str slice that is owned.

Examples

Basic usage:

let s1: String = String::from("hello world");
let s2: Box<str> = Box::from(s1);
let s3: String = String::from(s2);

assert_eq!("hello world", s3)

Converts a String into a box of dyn Error + Send + Sync.

Examples

use std::error::Error;
use std::mem;

let a_string_error = "a string error".to_string();
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_string_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

Converts a String into a box of dyn Error.

Examples

use std::error::Error;
use std::mem;

let a_string_error = "a string error".to_string();
let a_boxed_error = Box::<dyn Error>::from(a_string_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

Converts a String into a OsString.

This conversion does not allocate or copy memory.

Converts a String into a PathBuf

This conversion does not allocate or copy memory.

Allocate a reference-counted string slice and copy v into it.

Example

let original: String = "statue".to_owned();
let shared: Rc<str> = Rc::from(original);
assert_eq!("statue", &shared[..]);

Allocate a reference-counted str and copy v into it.

Example

let unique: String = "eggplant".to_owned();
let shared: Arc<str> = Arc::from(unique);
assert_eq!("eggplant", &shared[..]);

Converts the given String to a vector Vec that holds values of type u8.

Examples

Basic usage:

let s1 = String::from("hello world");
let v1 = Vec::from(s1);

for b in v1 {
    println!("{}", b);
}

Converts a RecvError into a RecvTimeoutError.

This conversion always returns RecvTimeoutError::Disconnected.

No data is allocated on the heap.

Converts a RecvError into a TryRecvError.

This conversion always returns TryRecvError::Disconnected.

No data is allocated on the heap.

Converts a Vec<NonZeroU8> into a CString without copying nor checking for inner null bytes.

Convert a serde_json::Error into an io::Error.

JSON syntax and data errors are turned into InvalidData IO errors. EOF errors are turned into UnexpectedEof IO errors.

use std::io;

enum MyError {
    Io(io::Error),
    Json(serde_json::Error),
}

impl From<serde_json::Error> for MyError {
    fn from(err: serde_json::Error) -> MyError {
        use serde_json::error::Category;
        match err.classify() {
            Category::Io => {
                MyError::Io(err.into())
            }
            Category::Syntax | Category::Data | Category::Eof => {
                MyError::Json(err)
            }
        }
    }
}

String converstion.

Converts from the domain type (which is represented as a vector of ics23::ProofSpec to the corresponding proto type (vector of ibc_proto::ProofSpec). TODO: fix with https://github.com/informalsystems/ibc-rs/issues/853

Converts a &str into a Box<str>

This conversion allocates on the heap and performs a copy of s.

Examples

let boxed: Box<str> = Box::from("hello");
println!("{}", boxed);

Converts a str into a box of dyn Error.

Examples

use std::error::Error;
use std::mem;

let a_str_error = "a str error";
let a_boxed_error = Box::<dyn Error>::from(a_str_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

Allocate a reference-counted string slice and copy v into it.

Example

let shared: Rc<str> = Rc::from("statue");
assert_eq!("statue", &shared[..]);

Converts a &str into a String.

The result is allocated on the heap.

Allocate a reference-counted str and copy v into it.

Example

let shared: Arc<str> = Arc::from("eggplant");
assert_eq!("eggplant", &shared[..]);

Allocate a Vec<u8> and fill it with a UTF-8 string.

Examples

assert_eq!(Vec::from("123"), vec![b'1', b'2', b'3']);

Creates a boxed Path from a reference.

This will allocate and clone path to it.

Converts a Path into an Rc by copying the Path data into a new Rc buffer.

Converts a Path into an Arc by copying the Path data into a new Arc buffer.

Converts a &String into a String.

This clones s and returns the clone.

Converts a Path into a Rc by copying the Path data into a new Rc buffer.

Converts a &mut str into a String.

The result is allocated on the heap.

Creates a boxed Path from a clone-on-write pointer.

Converting from a Cow::Owned does not clone or allocate.

Converts a borrowed OsStr to a PathBuf.

Allocates a PathBuf and copies the data into it.

Converts a &[T] into a Box<[T]>

This conversion allocates on the heap and performs a copy of slice.

Examples

// create a &[u8] which will be used to create a Box<[u8]>
let slice: &[u8] = &[104, 101, 108, 108, 111];
let boxed_slice: Box<[u8]> = Box::from(slice);

println!("{:?}", boxed_slice);

Allocate a reference-counted slice and fill it by cloning v’s items.

Example

let original: &[i32] = &[1, 2, 3];
let shared: Rc<[i32]> = Rc::from(original);
assert_eq!(&[1, 2, 3], &shared[..]);

Allocate a reference-counted slice and fill it by cloning v’s items.

Example

let original: &[i32] = &[1, 2, 3];
let shared: Arc<[i32]> = Arc::from(original);
assert_eq!(&[1, 2, 3], &shared[..]);

Allocate a Vec<T> and fill it by cloning s’s items.

Examples

assert_eq!(Vec::from(&[1, 2, 3][..]), vec![1, 2, 3]);

Allocate a Vec<T> and fill it by cloning s’s items.

Examples

assert_eq!(Vec::from(&mut [1, 2, 3][..]), vec![1, 2, 3]);

Converts a string slice into a Borrowed variant. No heap allocation is performed, and the string is not copied.

Example

assert_eq!(Cow::from("eggplant"), Cow::Borrowed("eggplant"));

Creates a clone-on-write pointer from a reference to Path.

This conversion does not clone or allocate.

Creates a clone-on-write pointer from a reference to PathBuf.

This conversion does not clone or allocate.

Converts a String reference into a Borrowed variant. No heap allocation is performed, and the string is not copied.

Example

let s = "eggplant".to_string();
assert_eq!(Cow::from(&s), Cow::Borrowed("eggplant"));

Converts a Cow into a box of dyn Error.

Examples

use std::error::Error;
use std::mem;
use std::borrow::Cow;

let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error>::from(a_cow_str_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

Converts a clone-on-write string to an owned instance of String.

This extracts the owned string, clones the string if it is not already owned.

Example

// If the string is not owned...
let cow: Cow<str> = Cow::Borrowed("eggplant");
// It will allocate on the heap and copy the string.
let owned: String = String::from(cow);
assert_eq!(&owned[..], "eggplant");

Converts a clone-on-write pointer to an owned path.

Converting from a Cow::Owned does not clone or allocate.

Creates a clone-on-write pointer from an owned instance of PathBuf.

This conversion does not clone or allocate.

Converts a String into an Owned variant. No heap allocation is performed, and the string is not copied.

Example

let s = "eggplant".to_string();
let s2 = "eggplant".to_string();
assert_eq!(Cow::from(s), Cow::<'static, str>::Owned(s2));

Converts a str into a box of dyn Error + Send + Sync.

Examples

use std::error::Error;
use std::mem;

let a_str_error = "a str error";
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_str_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

Converts a Cow into a box of dyn Error + Send + Sync.

Examples

use std::error::Error;
use std::mem;
use std::borrow::Cow;

let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_cow_str_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

Create a reference-counted pointer from a clone-on-write pointer by copying its content.

Example

let cow: Cow<str> = Cow::Borrowed("eggplant");
let shared: Rc<str> = Rc::from(cow);
assert_eq!("eggplant", &shared[..]);

Create an atomically reference-counted pointer from a clone-on-write pointer by copying its content.

Example

let cow: Cow<str> = Cow::Borrowed("eggplant");
let shared: Arc<str> = Arc::from(cow);
assert_eq!("eggplant", &shared[..]);

Converts a type of Error + Send + Sync into a box of dyn Error + Send + Sync.

Examples

use std::error::Error;
use std::fmt;
use std::mem;

#[derive(Debug)]
struct AnError;

impl fmt::Display for AnError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f , "An error")
    }
}

impl Error for AnError {}

unsafe impl Send for AnError {}

unsafe impl Sync for AnError {}

let an_error = AnError;
assert!(0 == mem::size_of_val(&an_error));
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(an_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

Converts a type of Error into a box of dyn Error.

Examples

use std::error::Error;
use std::fmt;
use std::mem;

#[derive(Debug)]
struct AnError;

impl fmt::Display for AnError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f , "An error")
    }
}

impl Error for AnError {}

let an_error = AnError;
assert!(0 == mem::size_of_val(&an_error));
let a_boxed_error = Box::<dyn Error>::from(an_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

Converts from &Option<T> to Option<&T>.

Examples

Converts an Option<String> into an Option<usize>, preserving the original. The map method takes the self argument by value, consuming the original, so this technique uses as_ref to first take an Option to a reference to the value inside the original.

let s: Option<String> = Some(String::from("Hello, Rustaceans!"));
let o: Option<usize> = Option::from(&s).map(|ss: &String| ss.len());

println!("Can still print s: {:?}", s);

assert_eq!(o, Some(18));

Creates a Borrowed variant of Cow from a reference to Vec.

This conversion does not allocate or clone the data.

Converts from &mut Option<T> to Option<&mut T>

Examples

let mut s = Some(String::from("Hello"));
let o: Option<&mut String> = Option::from(&mut s);

match o {
    Some(t) => *t = String::from("Hello, Rustaceans!"),
    None => (),
}

assert_eq!(s, Some(String::from("Hello, Rustaceans!")));

Convert a clone-on-write slice into a vector.

If s already owns a Vec<T>, it will be returned directly. If s is borrowing a slice, a new Vec<T> will be allocated and filled by cloning s’s items into it.

Examples

let o: Cow<[i32]> = Cow::Owned(vec![1, 2, 3]);
let b: Cow<[i32]> = Cow::Borrowed(&[1, 2, 3]);
assert_eq!(Vec::from(o), Vec::from(b));

Creates a Borrowed variant of Cow from a slice.

This conversion does not allocate or clone the data.

Creates an Owned variant of Cow from an owned instance of Vec.

This conversion does not allocate or clone the data.

Converts a Box<str> into a Box<[u8]>

This conversion does not allocate on the heap and happens in place.

Examples

// create a Box<str> which will be used to create a Box<[u8]>
let boxed: Box<str> = Box::from("hello");
let boxed_str: Box<[u8]> = Box::from(boxed);

// create a &[u8] which will be used to create a Box<[u8]>
let slice: &[u8] = &[104, 101, 108, 108, 111];
let boxed_slice = Box::from(slice);

assert_eq!(boxed_slice, boxed_str);

Converts a tuple struct (Into<IpAddr>, u16) into a SocketAddr.

This conversion creates a SocketAddr::V4 for a IpAddr::V4 and creates a SocketAddr::V6 for a IpAddr::V6.

u16 is treated as port of the newly created SocketAddr.

Stability note: This impl does not yet exist, but we are “reserving space” to add it in the future. See rust-lang/rust#64715 for details.

Move a boxed object to a new, reference counted, allocation.

Example

let original: Box<i32> = Box::new(1);
let shared: Rc<i32> = Rc::from(original);
assert_eq!(1, *shared);

Move a boxed object to a new, reference-counted allocation.

Example

let unique: Box<str> = Box::from("eggplant");
let shared: Arc<str> = Arc::from(unique);
assert_eq!("eggplant", &shared[..]);

Converts a BinaryHeap<T> into a Vec<T>.

This conversion requires no data movement or allocation, and has constant time complexity.

Turn a VecDeque<T> into a Vec<T>.

This never needs to re-allocate, but does need to do O(n) data movement if the circular buffer doesn’t happen to be at the beginning of the allocation.

Examples

use std::collections::VecDeque;

// This one is *O*(1).
let deque: VecDeque<_> = (1..5).collect();
let ptr = deque.as_slices().0.as_ptr();
let vec = Vec::from(deque);
assert_eq!(vec, [1, 2, 3, 4]);
assert_eq!(vec.as_ptr(), ptr);

// This one needs data rearranging.
let mut deque: VecDeque<_> = (1..5).collect();
deque.push_front(9);
deque.push_front(8);
let ptr = deque.as_slices().1.as_ptr();
let vec = Vec::from(deque);
assert_eq!(vec, [8, 9, 1, 2, 3, 4]);
assert_eq!(vec.as_ptr(), ptr);

Converts a SendError<T> into a TrySendError<T>.

This conversion always returns a TrySendError::Disconnected containing the data in the SendError<T>.

No data is allocated on the heap.

Converts a Vec<T> into a BinaryHeap<T>.

This conversion happens in-place, and has O(n) time complexity.

Turn a Vec<T> into a VecDeque<T>.

This avoids reallocating where possible, but the conditions for that are strict, and subject to change, and so shouldn’t be relied upon unless the Vec<T> came from From<VecDeque<T>> and hasn’t been reallocated.

Allocate a reference-counted slice and move v’s items into it.

Example

let original: Box<Vec<i32>> = Box::new(vec![1, 2, 3]);
let shared: Rc<Vec<i32>> = Rc::from(original);
assert_eq!(vec![1, 2, 3], *shared);

Allocate a reference-counted slice and move v’s items into it.

Example

let unique: Vec<i32> = vec![1, 2, 3];
let shared: Arc<[i32]> = Arc::from(unique);
assert_eq!(&[1, 2, 3], &shared[..]);

Convert the CtOption<T> wrapper into an Option<T>, depending on whether the underlying is_some Choice was a 0 or a 1 once unwrapped.

Note

This function exists to avoid ending up with ugly, verbose and/or bad handled conversions from the CtOption<T> wraps to an Option<T> or Result<T, E>. This implementation doesn’t intend to be constant-time nor try to protect the leakage of the T since the Option<T> will do it anyways.

Copies val into a new Some.

Examples

let o: Option<u8> = Option::from(67);

assert_eq!(Some(67), o);

Convert to a Ready variant.

Example

assert_eq!(Poll::from(true), Poll::Ready(true));

Converts a T into a Box<T>

The conversion allocates on the heap and moves t from the stack into it.

Examples

let x = 5;
let boxed = Box::new(5);

assert_eq!(Box::from(x), boxed);

Converts a generic type T into a Rc<T>

The conversion allocates on the heap and moves t from the stack into it.

Example

let x = 5;
let rc = Rc::new(5);

assert_eq!(Rc::from(x), rc);

Creates a new mutex in an unlocked state ready for use. This is equivalent to Mutex::new.

Creates a new instance of an RwLock<T> which is unlocked. This is equivalent to RwLock::new.

Convert a boxed slice into a vector by transferring ownership of the existing heap allocation.

Examples

let b: Box<[i32]> = vec![1, 2, 3].into_boxed_slice();
assert_eq!(Vec::from(b), vec![1, 2, 3]);

Converts a Box<T> into a Pin<Box<T>>

This conversion does not allocate on the heap and happens in place.

Convert a vector into a boxed slice.

If v has excess capacity, its items will be moved into a newly-allocated buffer with exactly the right capacity.

Examples

assert_eq!(Box::from(vec![1, 2, 3]), vec![1, 2, 3].into_boxed_slice());

Converts a [T; N] into a Box<[T]>

This conversion moves the array to newly heap-allocated memory.

Examples

let boxed: Box<[u8]> = Box::from([4, 2]);
println!("{:?}", boxed);

Use a Wake-able type as a RawWaker.

No heap allocations or atomic operations are used for this conversion.

Use a Wake-able type as a Waker.

No heap allocations or atomic operations are used for this conversion.